﻿#include<iostream>
#include<queue>
#include<array>
using namespace std;

//template<size_t N = 10>
//class stack
//{
//	/*size_t size
//	{
//		return N;
//	}*/
//
//private:
//	int arr[N];
//	int top;
//};

template<class T>
class Func
{
public:
	Func() { cout << "Func<class T>"; }
};

template<class T1>
class Func<T1*>
{
public:
	Func() { cout << "Func<class T>"; }
};

template<class T1>
class Func<T1&>
{
public:
	Func() { cout << "Func<class T>"; }
};

template <class T1,class T2>
class Dun
{
	Dun() { cout << "Dun<class T1,class T2>"; }
};

template <>
class Dun<int,double>
{
	Dun() { cout << "Dun<class T1,class T2>"; }
};

template <class T>
class Dun<T*,int>
{
	Dun() { cout << "Dun<class T1,class T2>"; }
};

template <class T>
class Dun<T&, double>
{
	Dun() { cout << "Dun<class T1,class T2>"; }
};

//int main()
//{
//	Func<int> f1;
//	Func<int*> f2;
//	Func<int&> f3;
//
//	return 0;
//}
template<typename Type>
Type Max(const Type& a, const Type& b)
{

	cout << "This is Max<Type>" << endl;

	return a > b ? a : b;

}
template<>
int Max<int>(const int& a, const int& b)

{

	cout << "This is Max<int>" << endl;

	return a > b ? a : b;

}
template<>
char Max<char>(const char& a, const char& b)

{

	cout << "This is Max<char>" << endl;

	return a > b ? a : b;

}
int Max(const int& a, const int& b)

{

	cout << "This is Max" << endl;

	return a > b ? a : b;

}
//int main()
//
//{
//
//	Max(10, 20);
//
//	Max(12.34, 23.45);
//
//	Max('A', 'B');
//
//	Max<int>(20, 30);
//
//	return 0;
//
//}

//template<class T>
//class Less<T*,T&>
//{
//	return x < y;
//}

//类模板的特化
//template<>
//bool Less<queue*>(queue* const & x,queue * const& y)
//{
//	return *x < *y;
//}


//int main()
//{
//	/*stack<> st;
//	stack<9>s;
//	stack<90>s1;*/
//
//	array<int,100> q1;
//
//	//越界检查的问题
//	//静态数组，抽查
//	//越界读不检查，越界写抽查
//
//	//而array越界读写都可以检查
//	cout << q1[99] << endl;
//
//	return 0;
//}


/////////////////////////////////////////////////////////////////
//继承:

//class person
//{
//
//protected:
//
//
//private:
//	string name;
//	string ip;
//	int age;
//
//};
//
//
//class student :public person
//{
//	student(const string&x)
//	{
//		
//	}
//
//private:
//	string address;
//};
//
//int main()
//{
//
//	student st;
//	
//
//
//	return 0;
//}

namespace bit
{
	//template<class T>
	//class vector
	//{};
	// stack和vector的关系，既符合is-a，也符合has-a
	template<class T>
	class stack : public std::vector<T>
	{
		public :
		void push(const T& x)
		{
			// 基类是类模板时，需要指定⼀下类域，
			// 否则编译报错:error C3861: “push_back”: 找不到标识符
			// 因为stack<int>实例化时，也实例化vector<int>了
			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
			vector<T>::push_back(x);
			//push_back(x);
		} 
		void pop()
		{
			vector<T>::pop_back();
		} 
		const T& top()
		{
			return vector<T>::back();
		} 
		bool empty()
		{
			return vector<T>::empty();
		}
	};


	//模版的按需实例化：例样
	/*template<class T>
	class AA
	{

		void push(const T&x)
		{
			x.funch();
		}
	};*/

}


//int main()
//{
//	bit::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	} 
//	return 0;
//}

//class B
//{
//public:
//	void fun()
//	{
//		cout << "class B" << endl;
//	}
//};
//
////成员函数名相同就构成隐藏
////想要调用父类的成员函数，就指定作用域
//class A :public B
//{
//public:
//	void fun(int x)
//	{
//		cout << "class A" << endl;
//	}
//};
//
//int main()
//{
//	A a;
//	a.fun(1);
//	//a.fun();//编译报错
//	a.B::fun();//指定作用域
//	return 0;
//}

class Person
{
public :
	Person(const char* name)
		: _name(name)
	{
		cout << "Person()" << endl;
	} 
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	} 
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	} 
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class student :public Person
{
public:
	student(const char* name, int num, const char* address)
		:Person(name)
		, _num(num)
		, _address(address)
	{
		cout << "student(char * s,int num = 1,const char* address )" << endl;
	}


	//严格说student默认拷贝构造生成的就够用了
	//如果需要深拷贝的资源，才需要自己实现
	student(const student& s)
		:Person(s)
		, _num(s._num)
		, _address(s._address)
	{}

	//严格说student默认赋值拷贝生成的就够用了
	//如果需要深拷贝的资源，才需要自己实现
	student& operator=(const student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

	//严格说student析构默认生成的就够用了
	//如果需要显示释放的资源，才需要自己实现
	~student()
	{
		//子类的析构和父类的析构也构成隐藏关系，需要指定父类的作用域
		//规定：不需要显示调用，子类析构函数之后，会自动调用父类的默认析构
		//这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证先子后父
		// Person::~Person();

	}

protected:
	int _num=22;
	string _address="江西";
};

//int main()
//{
//	student st("张三" , 22 ,"江西");
//	student s1(st);
//
//	return 0;
//}

//C++11的方法
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	//// C++98的⽅法
//	//Base()
//	//{}
//};

class Base 
{
	public :
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private:
	// C++98的⽅法
	Base()
	{}
};

class Deriv :public Base
{
	void func()
	{
		cout << "class Deriv :public Base" << endl;
	}
};

int main()
{
	//Deriv d;


	return 0;
}